﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;
using System.Collections.ObjectModel;
using System.Data;
using System.Windows.Media.Imaging;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Controls;
using System.Globalization;
using produccion.modelo;
using produccion.AccesoDatos;
using produccion.clases;
using System.Windows.Input;
using System.Collections.Specialized;

namespace produccion.vistamodelo
{
    class VMDevolucionMatPri : ViewModelBase, IDataErrorInfo
    {

        #region Campos
       
        private CLSSEMANAS _semana = new CLSSEMANAS();
        private CLSMAEEMPP _empleado = new CLSMAEEMPP();
        private List<CLSPRCPRD> _procesos = new List<CLSPRCPRD>();
        private CLSPRCPRD _selProceso = new CLSPRCPRD();

        private ProcesoProduccionRepositorio _repositorio = new ProcesoProduccionRepositorio();

        #endregion Campos

        #region Constructor
            public VMDevolucionMatPri()
            {
                consultarOrdenesProd();
                consultar_semana("I");
                this.lisOrdenes.CollectionChanged += this.OnCollectionChanged;

                if (MDOgeneral.conexion == null || MDOgeneral.conexion.State == ConnectionState.Closed)
                {
                    MDOgeneral.conectar();
                }
                strTituloVentana = "Devolución de materia prima - Usuario: " + MDOgeneral.usuario + " - [FRMDevolucionMatPri]";
            }
        #endregion

        #region comandos

        RelayCommand _cmdBuscarOperario;
        public ICommand cmdBuscarOperario
        {
            get
            {

                if (_cmdBuscarOperario == null)
                {
                    _cmdBuscarOperario = new RelayCommand(parameter =>BuscarOperario());
                }
                return _cmdBuscarOperario;
            }
        }

        RelayCommand _cmdSalir;
        public ICommand cmdSalir
        {
            get
            {

                if (_cmdSalir == null)
                {
                    _cmdSalir = new RelayCommand(Salir);
                }
                return _cmdSalir;
            }
        }

        RelayCommand _cmdValOrden;
        public ICommand cmdValOrden
        {
            get
            {

                if (_cmdValOrden == null)
                {
                    _cmdValOrden = new RelayCommand(x=>ValOrden());
                }
                return _cmdValOrden;
            }
        }

        RelayCommand _cmdValMaterial;
        public ICommand cmdValMaterial
        {
            get
            {

                if (_cmdValMaterial == null)
                {
                    _cmdValMaterial = new RelayCommand(x=>ValMaterial());
                }
                return _cmdValMaterial;
            }
        }

        RelayCommand _cmdGuardar;
        public ICommand cmdGuardar
        {
            get
            {
                if (_cmdGuardar == null)
                {
                    _cmdGuardar = new RelayCommand(param => this.guardar()
                        );
                }
                return _cmdGuardar;
            }
        }

        #endregion comandos

        #region metodos

        private void cargar_Empleados()
        {
            try
            {
                List<CLSMAEEMPP> lisemplea = new CLSMAEEMPP().listaEmpleados();
                _buscarEmpleado = new VMbuscarGeneral((from emp in lisemplea
                    select new VMlistaGenerica { strColumna1 = emp.CODEMP_EMP, strColumna2 = emp.CEDEMP_EMP, strColumna3 = emp.NOMEMP_EMP }).ToList());
                buscarEmpleado.PropertyChanged += onBuscarGrupoPropertyChanged;
                buscarEmpleado.gridBuscar.columna1.strNombre = "Código";
                buscarEmpleado.gridBuscar.columna2.strNombre = "Cedula";
                buscarEmpleado.gridBuscar.columna3.strNombre = "Nombre grupo";
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void ValOrden() 
        {
            try 
            {
                logOrdenValido = !lisOrdenes.Any(x=>x.IsValid==false);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        void ValMaterial() 
        {
            try 
            {
                selOrden.logMaterialValido = !selOrden.lisRepDev.Any(x => x.IsValid == false);
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void consultarOrdenesProd() 
        {
            try
            {
                procesos = new CLSPRCPRD().listarProcesosDevolucion();
            }
            catch (Exception ex)
            { MessageBox.Show(ex.Message); }
        }

        private void consultar_semana(string sw)
        {
            try
            { 
                _semana=_repositorio.consultar_Semana(_semana,sw);
                base.OnPropertyChanged("numSemana");
                base.OnPropertyChanged("dtmDesde");
                base.OnPropertyChanged("dtmHasta");
            }
            catch (Exception ex)
            { MessageBox.Show(ex.Message); }
        }

        private void consultar_empleado()
        {
            try
            {
                _empleado.consultar();
                base.OnPropertyChanged("strNombreEmpleado"); 
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void BuscarOperario()
        {
            try
            {
                buscarEmpleado.IsOpen = true;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void Salir(object frmFormulario)
        {
            ((Window)frmFormulario).Close();
        }

        private void consultaDevolucionEmpleado()
        {
            
            try
            {
               List<CLSENCORDP> ordenes= _repositorio.consultarDevolucionOperario(_semana, _empleado, _selProceso);
               List<VMordenes> all = (from cust in ordenes select new VMordenes(cust,validarOrden)).ToList();
               foreach (VMordenes cvm in all)
                   cvm.PropertyChanged += this.OnVMordenesPropertyChanged;
               this.lisOrdenes = new ObservableCollection<VMordenes>(all);
               this.lisOrdenes.CollectionChanged += this.OnCollectionChanged;

            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        private void consultaOrden() {
            try {

            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        string validarOrden(string strOrden)
        {
            //if (String.IsNullOrEmpty(strOrden)) 
            //{
            //    return "La orden no puede estar vacia.";
            //}
            int num=lisOrdenes.ToList().Count(x=>!String.IsNullOrEmpty(x.strOrden) && x.strOrden.Trim().Equals(strOrden.Trim()));
            if (num > 1) 
            {
                return "El Numero De Orden Ingresado ya Existe.";
            }
            return null;
        }

        public void guardar()                   
        {
            try
            {
                List<CLSENCORDP> _ordenes = (from cust in lisOrdenes select cust.getOrdenes()).ToList(); 
                if (_repositorio.guardarDevolucion(_ordenes, _semana, _selProceso))
                {
                    limpiar();
                    msn.texto = "Devolución guardada con exito.";
                    msn.tipo = true;
                }
                else
                {
                    msn.texto = "La devolución no puede ser guardada.";
                    msn.tipo = false;
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        private void limpiar()
        {
            try
            {
                strEmpleado = "";
                selOrden = null;
                lisOrdenes = null;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        #endregion

        #region eventos

        void onBuscarGrupoPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            try
            {
                if (e.PropertyName == "IsOpen")
                {
                    if (!buscarEmpleado.IsOpen)
                    {
                        if (buscarEmpleado.gridBuscar.selLista != null)
                        {
                            strEmpleado = buscarEmpleado.gridBuscar.selLista.strColumna1;
                        }
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.NewItems != null && e.NewItems.Count != 0)
            {
                foreach (VMordenes custVM in e.NewItems)
                {
                    custVM.PropertyChanged += this.OnVMordenesPropertyChanged;
                    custVM.validarColeccion+= this.validarOrden;
                }
            }
        }

        void OnVMordenesPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            (sender as VMordenes).VerifyPropertyName("strOrden");
            if (e.PropertyName == "strOrden") { }
        }
        #endregion
        
        #region interfaces publicas o propiedades

        private string _strTituloVentana;
        public string strTituloVentana
        {
            get { return _strTituloVentana; }
            set { _strTituloVentana = value; base.OnPropertyChanged("strTituloVentana"); }
        }

        private VMbuscarGeneral _buscarEmpleado;
        public VMbuscarGeneral buscarEmpleado
        {
            get { return _buscarEmpleado; }
            set { _buscarEmpleado = value; base.OnPropertyChanged("buscarEmpleado"); }
        }

        public int numSemana
        {
            get { return _semana.NROSEM_SEM; }
            set { _semana.NROSEM_SEM = value;
                consultar_semana("S");
                base.OnPropertyChanged("numSemana"); }
        }

        public DateTime dtmDesde
        {
            get { return _semana.DESDE_SEM; }
            set { _semana.DESDE_SEM = value; base.OnPropertyChanged("dtmDesde"); }
        }

        public DateTime dtmHasta
        {
            get { return _semana.HASTA_SEM; }
            set { 
                    _semana.HASTA_SEM = value;
                    consultar_semana("F");
                    base.OnPropertyChanged("dtmHasta"); 
                }
        }

        public string strNombreEmpleado
        {
            get { return _empleado.NOMEMP_EMP; }
            set { _empleado.NOMEMP_EMP = value; base.OnPropertyChanged("strNombreEmpleado"); }
        }

        public string strEmpleado
        {
            get { return _empleado.CODEMP_EMP; }
            set { 
                    _empleado.CODEMP_EMP = value;
                    consultar_empleado();
                    if (strEmpleado.Length == 5 && _empleado.EXISTE)
                    {
                        consultaDevolucionEmpleado();
                    }
                    base.OnPropertyChanged("strEmpleado"); 
                }
        }

        public List<CLSPRCPRD> procesos
        {
            get { return _procesos; }
            set { _procesos = value; base.OnPropertyChanged("procesos"); }
        }

        public CLSPRCPRD selProceso
        {
            get { return _selProceso; }
            set { _selProceso = value; base.OnPropertyChanged("selProceso"); }
        }

        private Boolean _logOrdenValido = true;
        public Boolean logOrdenValido {
            get { return _logOrdenValido; }
            set { _logOrdenValido = value;
            base.OnPropertyChanged("logOrdenValido");
            }
        
        }
   
        private ObservableCollection<VMordenes> _lisOrdenes = new ObservableCollection<VMordenes>();
        public ObservableCollection<VMordenes> lisOrdenes 
        { 
            get { return _lisOrdenes; }
            set { _lisOrdenes = value; base.OnPropertyChanged("lisOrdenes"); }
        }

        private VMordenes _selOrden;
        public VMordenes selOrden
        {
            get { return _selOrden; }
            set {

                if (_selOrden == null) 
                    _selOrden = value;

                if (_selOrden == null)
                    return;

                if (_selOrden.logMaterialValido)
                    _selOrden = value;

                base.OnPropertyChanged("selOrden");
            }        
        }

        private MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
        public MDOgeneral.mensaje msn
        {
            get { return _msn; }
            set { _msn = value; base.OnPropertyChanged("msn"); }
        }

        #endregion 







        #region vistas modelos

        public class VMordenes : ViewModelBase, IDataErrorInfo
        {
            #region campos
            private CLSENCORDP _orden = new CLSENCORDP();
            private ProcesoProduccionRepositorio _rep=new ProcesoProduccionRepositorio();
            #endregion

            #region constructor

            public VMordenes()
            {
             
            }

            public VMordenes(CLSENCORDP orden, ValidateColeccion _validarColeccion)
            {
                _orden = orden;
                validarColeccion += _validarColeccion;
                cargarRepDev();
                this.activo = false;
            }

            #endregion

            #region metodos

            public CLSENCORDP getOrdenes() 
            {
                try 
                {
                    _orden.repDev = (from cust in lisRepDev select cust.getReporteDev()).ToList();
                    return _orden;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

            void cargarRepDev()
            {
                try
                {
                    List<VMmateriales> all = (from cust in _orden.repDev select new VMmateriales(cust)).ToList();
                    this.lisRepDev = new ObservableCollection<VMmateriales>(all);
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void consultarOrdenDev() {
                try {
                 _orden=_rep.ConsultaRepDevOrden(_orden);
                 cargarRepDev();
                 base.OnPropertyChanged("strReferencia");
                 base.OnPropertyChanged("strColor");
                 base.OnPropertyChanged("numCantidad");
                 base.OnPropertyChanged("strCortador1");
                 base.OnPropertyChanged("strCortador2");
                 base.OnPropertyChanged("strCortador3");
                 if (_orden.PORCOR1_EOP > 0)
                     logCortador1 = true;
                 if (_orden.PORCOR2_EOP > 0)
                     logCortador2 = true;
                 if (_orden.PORCOR3_EOP > 0)
                     logCortador3 = true;
                 base.OnPropertyChanged("lisRepDev");
                 base.OnPropertyChanged("lisRepDev");
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public delegate string ValidateColeccion(string orden);

            public delegate void OrdenValido(Boolean IsValid);
       
            #endregion

            #region interfaces publicas

            public ValidateColeccion validarColeccion { get; set; }
                
            public string strOrden
            {
                get { return _orden.NROORD_EOP; }
                set 
                {
                    _orden.NROORD_EOP = value;
                    if (_orden.NROORD_EOP != null)
                    {
                        if (_orden.NROORD_EOP.Length >= 6)
                        {
                            consultarOrdenDev();
                        }
                    }
                    
                    base.OnPropertyChanged("strOrden"); 
                }
            }

            public string strReferencia
            {
                get { return _orden.referencia.NOMREF_REF; }
                set { _orden.referencia.NOMREF_REF = value; base.OnPropertyChanged("strReferencia"); }
            }

            public string strColor
            {
                get { return _orden.color.NOMCOL_COL; }
                set { _orden.color.NOMCOL_COL = value; base.OnPropertyChanged("strColor"); }
            }

            public int numCantidad
            {
                get { return _orden.CANTIDAD; }
                set { _orden.CANTIDAD = value; base.OnPropertyChanged("numCantidad"); }
            }

            public string strCortador1
            {
                get { return _orden.CODCOR1_EOP; }
                set { _orden.CODCOR1_EOP = value; base.OnPropertyChanged("strCortador1"); }
            }

            public string strCortador2
            {
                get { return _orden.CODCOR2_EOP; }
                set { _orden.CODCOR2_EOP = value; base.OnPropertyChanged("strCortador2"); }
            }

            public string strCortador3
            {
                get { return _orden.CODCOR3_EOP; }
                set { _orden.CODCOR3_EOP = value; base.OnPropertyChanged("strCortador3"); }
            }

            public double numPorcentajeCortador1
            {
                get { return _orden.PORCOR1_EOP; }
                set { _orden.PORCOR1_EOP = value; base.OnPropertyChanged("numPorcentajeCortador1"); }
            }

            public double numPorcentajeCortador2
            {
                get { return _orden.PORCOR2_EOP; }
                set { _orden.PORCOR2_EOP = value; base.OnPropertyChanged("numPorcentajeCortador2"); }
            }

            public double numPorcentajeCortador3
            {
                get { return _orden.PORCOR3_EOP; }
                set { _orden.PORCOR3_EOP = value; base.OnPropertyChanged("numPorcentajeCortador3"); }
            }

            private Boolean _logCortador1 = false;
            public Boolean logCortador1
            {
                get { return _logCortador1; }
                set { _logCortador1 = value; base.OnPropertyChanged("logCortador1"); }
            }

            private Boolean _logCortador2 = false;
            public Boolean logCortador2
            {
                get { return _logCortador2; }
                set { _logCortador2 = value; base.OnPropertyChanged("logCortador2"); }
            }

            private Boolean _logCortador3 = false;
            public Boolean logCortador3
            {
                get { return _logCortador3; }
                set { _logCortador3 = value; base.OnPropertyChanged("logCortador3"); }
            }

            private Boolean _logMaterialValido = true;
            public Boolean logMaterialValido
            {
                get { return _logMaterialValido; }
                set { _logMaterialValido = value; base.OnPropertyChanged("logMaterialValido"); }
            }

            private ObservableCollection<VMmateriales> _lisRepDev = new ObservableCollection<VMmateriales>();
            public ObservableCollection<VMmateriales> lisRepDev 
            { 
                get { return _lisRepDev; } 
                set { _lisRepDev = value; base.OnPropertyChanged("lisRepDev"); } 
            }

            private Boolean _activo = true;
            public Boolean activo {
                get { return _activo; }
                set { _activo = value; base.OnPropertyChanged("activo"); }
            }

            #endregion

            #region IDataErrorInfo Members

            string IDataErrorInfo.Error { get { return null; } }

            string IDataErrorInfo.this[string propertyName]
            {
                get { return this.GetValidationError(propertyName); }
            }

            #endregion

            #region Validation

            /// <summary>
            /// Returns true if this object has no validation errors.
            /// </summary>
            /// 
           
            public bool IsValid
            {
                get
                {
                    foreach (string property in ValidatedProperties)
                        if (GetValidationError(property) != null)
                            return false;
                    return true;
                }
            }

            static readonly string[] ValidatedProperties = 
            { 
                "strOrden",
                "lisRepDev"
            };

            string GetValidationError(string propertyName)
            {
                if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                    return null;

                string error = null;

                switch (propertyName)
                {
                    case "strOrden":
                        error = this.ValidatestrOrden();
                        break;
                    case "lisRepDev":
                        error = this.ValidatelisRepDev();
                        break;
                    default:
                        Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                        break;
                }
                return error;
            }

            string ValidatestrOrden() {
                try 
                {
                    string error = null;
                     if (strOrden != null)
                    {
                        if (strOrden.Length == 6)
                        {
                            error = validarColeccion(strOrden);

                            if (strReferencia == null)
                                return "La Orden no existe o es invalida.";
                        }
                    }

                    return error;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

           string ValidatelisRepDev()
            {
               if( lisRepDev.Any(x => x.IsValid == false))
               {
                   return "El reporte de las devoluciones tiene error.";
               }
               return null;
            }

            #endregion


        }

        public class VMmateriales : ViewModelBase, IDataErrorInfo
        {

            #region campos
            private CLSREPDEV _repdev = new CLSREPDEV();
            #endregion

            public CLSREPDEV getReporteDev() {
                try { return _repdev; }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

            #region constructor

            public VMmateriales(CLSREPDEV repdev)
            {
                _repdev = repdev;
            }

            public VMmateriales()
            {
                // TODO: Complete member initialization
            }

            public delegate void MaterialValido(Boolean IsValid);
            
            public MaterialValido materialValido { get; set; }

            #endregion

            #region interfaces publicas

            public string strMaterial
            {
                get { return _repdev.CODMTP_RDV; }
                set { _repdev.CODMTP_RDV = value; base.OnPropertyChanged("strMaterial"); }
            }

            public string strNombreMaterial
            {
                get { return _repdev.maeMat.NOMMAT_MAT; }
                set { _repdev.maeMat.NOMMAT_MAT = value; base.OnPropertyChanged("strNombreMaterial"); }
            }
            
            public double numCantidadentregada
            {
                get { return _repdev.CANENT_RDV; }
                set { _repdev.CANENT_RDV = value; base.OnPropertyChanged("numCantidadentregada"); }
            }

            public double numCantidadDevuelta
            {
                get { return _repdev.CANDEV_RDV; }
                set { _repdev.CANDEV_RDV = value; base.OnPropertyChanged("numCantidadDevuelta"); }
            }

            private Boolean _hasError = false;
            public Boolean hasError
            {
                get { return _hasError; }
                set { _hasError = value; base.OnPropertyChanged("hasError"); }
            }

            #endregion

            #region IDataErrorInfo Members

            string IDataErrorInfo.Error { get { return null; } }

            string IDataErrorInfo.this[string propertyName]
            {
                get { return this.GetValidationError(propertyName); }
            }

            #endregion

            #region Validation

            /// <summary>
            /// Returns true if this object has no validation errors.
            /// </summary>
            public bool IsValid
            {
                get
                {

                    foreach (string property in ValidatedProperties)
                        if (GetValidationError(property) != null)
                            return false;
                   return true;
                }
            }

            static readonly string[] ValidatedProperties = 
            { 
                "numCantidadDevuelta"
            };

            string GetValidationError(string propertyName)
            {
                if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                    return null;

                string error = null;

                switch (propertyName)
                {
                    case "numCantidadDevuelta":
                        error = this.ValidateCantidadDev();
                        break;
                    default:
                        Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                        break;
                }

                return error;
            }

            string ValidateCantidadDev()
            {
                try
                {
                    //if (numCantidadDevuelta>numCantidadentregada) 
                    //{ 
                    //    return "La cantidad devuelta no puede ser mayor que la cantidad entregada."; 
                    //}
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }
            #endregion
        }

        #endregion

        #region IDataErrorInfo Members

        string IDataErrorInfo.Error { get { return null; } }

        string IDataErrorInfo.this[string propertyName]
        {
            get { return this.GetValidationError(propertyName); }
        }

        #endregion

        #region Validation

        /// <summary>
        /// Returns true if this object has no validation errors.
        /// </summary>
        public bool IsValid
        {
            get
            {
                foreach (string property in ValidatedProperties)
                    if (GetValidationError(property) != null)
                        return false;

                return true;
            }
        }

        static readonly string[] ValidatedProperties = 
        { 
            "numSemana", 
            "dtmDesde",
            "dtmHasta",
            "strEmpleado",
            "selProceso"
        };

        string GetValidationError(string propertyName)
        {
            if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                return null;

            string error = null;

            switch (propertyName)
            {
                case "numSemana":
                    error = this.ValidatenumSemana();
                    break;
                case "dtmDesde":
                    error = this.ValidatedtmDesde();
                    break;
                case "dtmHasta":
                    error = this.ValidatedtmHasta();
                    break;
                case "strEmpleado":
                    error = this.ValidatedstrEmpleado();
                    break;
                case "selProceso":
                    error = this.ValidatedselProceso();
                    break;
                default:
                    Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                    break;
            }
            return error;
        }

        string ValidatenumSemana()
        {
            int _numSemana = Convert.ToInt32(numSemana);
            if (_numSemana < 1 || _numSemana > 52)
            {
                return "El valor ingresado no es valido para una semana.";
            }
            return null;
        }

        string ValidatedtmDesde()
        {
            if (dtmDesde > dtmHasta)
            {
                return "La fecha inicial, debe ser menor o igual que la fecha final";
            }

            TimeSpan ts = dtmHasta.Subtract(dtmDesde);
            if (ts.Days > 7)
            {
                return "El rango de fechas no debe de ser mayor a una semana.";
            }
            return null;
        }

        string ValidatedtmHasta()
        {
            if (dtmHasta < dtmDesde)
            {
                return "La fecha final, debe ser mayor o igual que la fecha inicial";
            }

            TimeSpan ts = dtmHasta.Subtract(dtmDesde);
            if (ts.Days > 7)
            {
                return "El rango de fechas no debe de ser mayor a una semana.";
            }
            return null;
        }

        string ValidatedstrEmpleado()
        {
            if (strEmpleado == null) { return "El empleado no existe";  }

            if (strEmpleado != null)
            {
                if (strEmpleado.Length < 5)
                {
                    return "El código de empleado es de cinco caracteres.";
                }
                else
                {
                    if (!_empleado.EXISTE)
                    {
                        base.OnPropertyChanged("strNombreEmpleado");
                        return "El empleado no existe.";
                    }
                }
            }
            return null;
        }

        string ValidatedselProceso()
        {
            if (selProceso==null)
            {
                return "Debe seleccionar un proceso.";
            }
            return null;
        }

        #endregion

    }
}
